"use strict";
/*
 * @Descripttion:
 * @version:
 * @Author: wtzhang
 * @Date: 2021-06-03 15:24:17
 * @LastEditors: wtzhang
 * @LastEditTime: 2021-06-03 16:56:05
 */
// es5的定义方式
/**
 * function Person() {
  this.name = name;
  this.age = age;
  this.run = function () {
    console.log(this.name + '在运动');
  }
}
 */
// ts类的定义
// class Person {
//   name: string; // 属性 省略了前面的 public 的关键字
//   constructor(name: string) { // 构造函数  就是实例化类的时候触发的方法
//     this.name = name
//   }
//   run(): void {
//     console.log(this.name + '在学习');
//   }
// }
// // 实例化
// let p = new Person('jack')
// p.run() // jack在学习
// > es5 代码 等价于 class 创建的类
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var Person = /** @class */ (function () {
    function Person(name) {
        this.name = name;
    }
    Person.prototype.getName = function () {
        return this.name;
    };
    Person.prototype.setName = function (name) {
        this.name = name;
    };
    return Person;
}());
var p = new Person('jack');
console.log(p.getName()); // jack
p.setName('rose');
console.log(p.getName()); // rose
console.log('+++++++++++++++++++++++++++');
// ts中类的继承 extends super
var Person1 = /** @class */ (function () {
    function Person1(name) {
        this.name = name;
    }
    Person1.prototype.run = function () {
        return this.name + "\u5728\u8FD0\u52A8\uD83C\uDFC3";
    };
    return Person1;
}());
var p1 = new Person1('jack');
console.log(p1.run()); // jack在运动🏃
// 继承
var User = /** @class */ (function (_super) {
    __extends(User, _super);
    function User(name) {
        return _super.call(this, name) || this;
    }
    // 不仅可以继承 父类的 方法，你也可以扩展自己的 方法
    User.prototype.work = function () {
        console.log(this.name + "\u5728\u5DE5\u4F5C");
    };
    return User;
}(Person1));
var u = new User('rose');
console.log(u.run()); // rose在运动🏃
console.log(u.work()); // rose在工作
// > 不仅可以继承 父类的 方法，你也可以扩展自己的 方法
console.log('++++++++++++++继承后 父类，子类有同一个方法+++++++++++++');
var Father = /** @class */ (function () {
    function Father(name) {
        this.name = name;
    }
    Father.prototype.run = function () {
        return this.name + "\u5728\u8FD0\u52A8\uD83C\uDFC3-\u7236\u7C7B\u4E2D\u7684\u65B9\u6CD5";
    };
    return Father;
}());
// 继承
var Son = /** @class */ (function (_super) {
    __extends(Son, _super);
    function Son(name) {
        return _super.call(this, name) || this;
    }
    Son.prototype.run = function () {
        return this.name + "\u5728\u8FD0\u52A8-\u5B50\u7C7B\u4E2D\u7684\u65B9\u6CD5";
    };
    return Son;
}(Father));
var s = new Son('jack');
console.log(s.run()); // jack在运动-子类中的方法
// > 继承的时候，父类跟子类有同样的方法，继承者执行的方法就是 子类里面的方法
console.log('+++++++++++++类里面的修饰符++++++++++++++++++');
// > 类里面的修饰符，typescript里面定义属性的时候给我们提供了 三种修饰符
/**
 * 修饰符 | 功能特点
 * -- |:--
 * public | 公有  在类里面，子类，类外面都可以访问
 * protected | 保护类型  在类里面，子类可以访问，类外面无法访问
 * private | 私有   在类里面可以访问，子类，类外面无法访问
 */
// > 属性不加修饰符，默认公有
// 父类
var User2 = /** @class */ (function () {
    function User2(name) {
        this.name = name;
    }
    User2.prototype.run = function () {
        return this.name + "\u5728\u8FD0\u52A8\uD83C\uDFC3";
    };
    return User2;
}());
// 子类
var Son2 = /** @class */ (function (_super) {
    __extends(Son2, _super);
    function Son2(name) {
        return _super.call(this, name) || this;
    }
    return Son2;
}(User2));
var s2 = new Son2('jack');
console.log(s2.name); // jack
// > 可以访问
// class User2 {
//   protected name: string; // 保护属性
//   constructor(name: string) {
//     this.name = name;
//   }
//   run(): string {
//     return `${this.name}在运动🏃`
//   }
// }
// // 子类
// class Son2 extends User2 {
//   constructor(name: string) {
//     super(name)
//   }
// }
// let s2 = new Son2('jack')
// console.log(s2.name); 
// > 可以访问
// class User2 {
//   private name: string; // 保护属性
//   constructor(name: string) {
//     this.name = name;
//   }
//   run(): string {
//     return `${this.name}在运动🏃`
//   }
// }
// // 子类
// class Son2 extends User2 {
//   constructor(name: string) {
//     super(name)
//   }
// }
// let s2 = new Son2('jack')
// console.log(s2.name); 
// // > 可以访问
